package com.lv.common.utils

/**
 * 作者： ygx
 * 创建日期：2023/2/16 3:20 PM
 * 签名： 天行健，君子以自强不息；地势坤，君子以厚德载物。
 * -    _              _           _     _   ____  _             _ _
 * -   / \   _ __   __| |_ __ ___ (_) __| | / ___|| |_ _   _  __| (_) ___
 * -  / _ \ | '_ \ / _` | '__/ _ \| |/ _` | \___ \| __| | | |/ _` | |/ _ \
 * - / ___ \| | | | (_| | | | (_) | | (_| |  ___) | |_| |_| | (_| | | (_) |
 * -/_/   \_\_| |_|\__,_|_|  \___/|_|\__,_| |____/ \__|\__,_|\__,_|_|\___/
 * <p>
 * You never know what you can do until you try !
 * ----------------------------------------------------------------
 * 描述：List 封装
 */
object ListUtils {
    /**
     * string 转 Map
     */
    fun getStringToMap(str: String): Map<String, Any>? {
        //根据逗号截取字符串数组
        val str1 = str.split("&".toRegex()).toTypedArray()
        //创建Map对象
        val map: MutableMap<String, Any> = HashMap()
        //循环加入map集合
        for (i in str1.indices) {
            //根据":"截取字符串数组
            val str2 = str1[i].split("=".toRegex()).toTypedArray()
            //str2[0]为KEY,str2[1]为值
            map[str2[0]] = str2[1]
        }
        return map
    }

    /**
     * 分割指定数量的list
     * 输入参数：source 原List ， size 需要被切割成多少份
     */
    fun <T> averageAssign(source: List<T>, size: Int): List<List<T>> {
        val result = ArrayList<List<T>>()
        var remaider = source.size % size //(先计算出余数)
        val number = source.size / size  //然后是商
        var offset = 0//偏移量
        for (i in 0 until size) {
            var value: List<T>?
            if (remaider > 0) {
                value = source.subList(i * number + offset, (i + 1) * number + offset + 1)
                remaider--
                offset++
            } else {
                value = source.subList(i * number + offset, (i + 1) * number + offset)
            }
            result.add(value)
        }
        return result
    }

    /**
     * 分割元素数量相同的list
     * 输入参数：source 原List ， splitItemNum 每个集合里放几个元素
     */
    fun <T> averageAssignFixLength(source: List<T>?, splitItemNum: Int): List<List<T>> {
        val result = ArrayList<List<T>>()

        if (source != null && source.run { isNotEmpty() } && splitItemNum > 0) {
            if (source.size <= splitItemNum) {
                // 源List元素数量小于等于目标分组数量
                result.add(source)
            } else {
                // 计算拆分后list数量
                val splitNum =
                    if (source.size % splitItemNum == 0) source.size / splitItemNum else source.size / splitItemNum + 1

                var value: List<T>? = null
                for (i in 0 until splitNum) {
                    if (i < splitNum - 1) {
                        value = source.subList(i * splitItemNum, (i + 1) * splitItemNum)
                    } else {
                        // 最后一组
                        value = source.subList(i * splitItemNum, source.size)
                    }

                    result.add(value)
                }
            }
        }

        return result
    }


}
